///*******************************************************************************
// * Copyright (c) 2000, 2007 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * IBM Corporation - initial API and implementation
// *******************************************************************************/
//package org.eclipse.ui.tests.api;
//
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.HashMap;
//import java.util.HashSet;
//import java.util.List;
//import java.util.Set;
//
//import org.eclipse.core.commands.Command;
//import org.eclipse.core.commands.ExecutionException;
//import org.eclipse.core.commands.NotEnabledException;
//import org.eclipse.core.commands.NotHandledException;
//import org.eclipse.core.commands.ParameterizedCommand;
//import org.eclipse.core.commands.common.NotDefinedException;
//import org.eclipse.core.resources.IFile;
//import org.eclipse.core.resources.IMarker;
//import org.eclipse.core.resources.IProject;
//import org.eclipse.core.resources.IResource;
//import org.eclipse.core.runtime.IAdaptable;
//import org.eclipse.jface.util.IPropertyChangeListener;
//import org.eclipse.jface.util.PropertyChangeEvent;
//import org.eclipse.ui.IEditorInput;
//import org.eclipse.ui.IEditorPart;
//import org.eclipse.ui.IEditorReference;
//import org.eclipse.ui.IMemento;
//import org.eclipse.ui.IPageLayout;
//import org.eclipse.ui.IPerspectiveDescriptor;
//import org.eclipse.ui.IPerspectiveRegistry;
//import org.eclipse.ui.IViewPart;
//import org.eclipse.ui.IViewReference;
//import org.eclipse.ui.IWorkbenchPage;
//import org.eclipse.ui.IWorkbenchWindow;
//import org.eclipse.ui.IWorkingSet;
//import org.eclipse.ui.IWorkingSetManager;
//import org.eclipse.ui.PartInitException;
//import org.eclipse.ui.PlatformUI;
//import org.eclipse.ui.WorkbenchException;
//import org.eclipse.ui.XMLMemento;
//import org.eclipse.ui.commands.ICommandService;
//import org.eclipse.ui.handlers.IHandlerService;
//import org.eclipse.ui.ide.IDE;
//import org.eclipse.ui.internal.SaveableHelper;
//import org.eclipse.ui.internal.WorkbenchPage;
//import org.eclipse.ui.internal.WorkbenchPlugin;
//import org.eclipse.ui.internal.registry.IActionSetDescriptor;
//import org.eclipse.ui.part.FileEditorInput;
//import org.eclipse.ui.tests.PerspectiveState;
//import org.eclipse.ui.tests.harness.util.CallHistory;
//import org.eclipse.ui.tests.harness.util.EmptyPerspective;
//import org.eclipse.ui.tests.harness.util.FileUtil;
//import org.eclipse.ui.tests.harness.util.UITestCase;
//
//public class IWorkbenchPageTest extends UITestCase {
//
// private IWorkbenchPage fActivePage;
//
// private IWorkbenchWindow fWin;
//
// private IProject proj;
//
// public IWorkbenchPageTest(String testName) {
// super(testName);
// }
//
// protected void doSetUp() throws Exception {
// super.doSetUp();
// fWin = openTestWindow();
// fActivePage = fWin.getActivePage();
// }
//
// protected void doTearDown() throws Exception {
// super.doTearDown();
// if (proj != null) {
// FileUtil.deleteProject(proj);
// proj = null;
// }
// }
//
// /**
// * Tests the new working set API.
// *
// * @since 3.2
// */
// public void testWorkingSets1() {
// IWorkbenchPage page = fActivePage;
// IWorkingSet[] sets = page.getWorkingSets();
// assertNotNull(sets);
// assertEquals(0, sets.length);
//
// IWorkingSetManager manager = page.getWorkbenchWindow().getWorkbench()
// .getWorkingSetManager();
//
// IWorkingSet set1 = null, set2 = null;
// try {
// set1 = manager.createWorkingSet("w1", new IAdaptable[0]);
// manager.addWorkingSet(set1);
// set2 = manager.createWorkingSet("w2", new IAdaptable[0]);
// manager.addWorkingSet(set2);
//
// page.setWorkingSets(new IWorkingSet[] { set1 });
// sets = page.getWorkingSets();
//
// assertNotNull(sets);
// assertEquals(1, sets.length);
// assertEquals(set1, sets[0]);
//
// page.setWorkingSets(new IWorkingSet[0]);
// sets = page.getWorkingSets();
// assertNotNull(sets);
// assertEquals(0, sets.length);
//
// page.setWorkingSets(new IWorkingSet[] { set1, set2 });
// sets = page.getWorkingSets();
//
// assertNotNull(sets);
// assertEquals(2, sets.length);
// Set realSet = new HashSet(Arrays.asList(sets));
// assertTrue(realSet.contains(set1));
// assertTrue(realSet.contains(set2));
//
// page.setWorkingSets(new IWorkingSet[0]);
// sets = page.getWorkingSets();
// assertNotNull(sets);
// assertEquals(0, sets.length);
// } finally {
// if (set1 != null)
// manager.removeWorkingSet(set1);
// if (set2 != null)
// manager.removeWorkingSet(set2);
// }
// }
//
// /**
// * Tests the new working set API.
// *
// * @since 3.2
// */
// public void testWorkingSets2() {
// fActivePage.setWorkingSets(null);
// IWorkingSet[] sets = fActivePage.getWorkingSets();
// assertNotNull(sets);
// assertEquals(0, sets.length);
// }
//
// /**
// * Tests the working set listeners.
// *
// * @since 3.2
// */
// public void testWorkingSets3() {
// IWorkingSetManager manager = fActivePage.getWorkbenchWindow()
// .getWorkbench().getWorkingSetManager();
//
// IWorkingSet set1 = null;
// final IWorkingSet[][] sets = new IWorkingSet[1][];
// sets[0] = new IWorkingSet[0];
// IPropertyChangeListener listener = new IPropertyChangeListener() {
//
// public void propertyChange(PropertyChangeEvent event) {
// IWorkingSet[] oldSets = (IWorkingSet[]) event.getOldValue();
// assertTrue(Arrays.equals(sets[0], oldSets));
// sets[0] = (IWorkingSet[]) event.getNewValue();
// }
// };
// try {
// set1 = manager.createWorkingSet("w1", new IAdaptable[0]);
// manager.addWorkingSet(set1);
//
// fActivePage.addPropertyChangeListener(listener);
//
// fActivePage.setWorkingSets(new IWorkingSet[] { set1 });
// fActivePage.setWorkingSets(new IWorkingSet[] {});
// fActivePage.setWorkingSets(new IWorkingSet[] { set1 });
//
// sets[0] = fActivePage.getWorkingSets();
//
// assertNotNull(sets[0]);
// assertEquals(1, sets[0].length);
// assertEquals(set1, sets[0][0]);
//
// } finally {
// fActivePage.removePropertyChangeListener(listener);
// if (set1 != null)
// manager.removeWorkingSet(set1);
// }
// }
//
// /**
// * Test the VIEW_VISIBLE parameter for showView, opening the view in the
// * stack that does not contain the active view. Ensures that the created
// * view is not the active part but is the top part in its stack.
// */
// public void testView_VISIBLE2() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// try {
// page.setPerspective(WorkbenchPlugin.getDefault()
// .getPerspectiveRegistry().findPerspectiveWithId(
// "org.eclipse.ui.tests.api.ViewPerspective"));
//
// // create a part to be active
// IViewPart activePart = page.showView(MockViewPart.ID3);
//
// IViewPart createdPart = page.showView(MockViewPart.ID2, null,
// IWorkbenchPage.VIEW_VISIBLE);
//
// IViewPart[] stack = page.getViewStack(createdPart);
// assertEquals(2, stack.length);
//
// assertEquals(createdPart, stack[0]);
// assertEquals(page.findView(MockViewPart.ID), stack[1]);
//
// assertTrue(page.isPartVisible(createdPart));
//
// assertEquals(activePart, page.getActivePart());
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
//
// /**
// * openEditor(IEditorInput input, String editorId, boolean activate)
// */
// public void testOpenEditor4() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final String id = MockEditorPart.ID1;
// IEditorInput input = new FileEditorInput(FileUtil.createFile(
// "test.mock1", proj));
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// CallHistory callTrace = listener.getCallHistory();
//
// /*
// * javadoc: The editor type is determined by mapping editorId to an
// * editor extension registered with the workbench. javadoc: If activate ==
// * true the editor will be activated
// */
// // open an editor with activation
// // Start with a view active in order to verify that the editor gets
// // activated
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// callTrace.clear();
// IEditorPart editor = IDE.openEditor(fActivePage, input, id, true);
// assertEquals(editor.getEditorInput(), input);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("partActivated"), true);
//
// // we need another editor so that the editor under test can receive
// // events.
// // otherwise, events will be ignored.
// IEditorPart extra = IDE.openEditor(fActivePage, FileUtil.createFile(
// "aaaaa", proj));
//
// // close the first editor after the second has opened; necessary for
// // test to work with fix to PR 7743
// fActivePage.closeEditor(editor, false);
//
// // Start with a view active in order to verify that the editor does not
// // get activated
// // (note: regardless of the activate=false flag, the editor would always
// // be activated
// // if it is being opened in the same stack as the active editor. Making
// // a view active
// // initially tests the function of the activate flag)
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// callTrace.clear();
// // open an editor without activation
// editor = IDE.openEditor(fActivePage, input, id, false);
//
// assertEquals(editor.getEditorInput(), input);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(hasEditor(editor), true);
// assertEquals(callTrace.contains("partActivated"), false);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
//
// fActivePage.activate(extra);
//
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is brought to the front
// */
// // open the editor under test second time without activation
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// callTrace.clear();
// assertEquals(IDE.openEditor(fActivePage, input, id, false), editor);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
// assertEquals(callTrace.contains("partActivated"), false);
//
// // activate the other editor
// fActivePage.activate(extra);
//
// /*
// * javadoc: If activate == true the editor will be activated
// */
// // open the editor under test second time with activation
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// callTrace.clear();
// assertEquals(IDE.openEditor(fActivePage, input, id, true), editor);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
// assertEquals(callTrace.contains("partActivated"), true);
//
// /*
// * javadoc: If activate == false but another editor in the same stack
// * was active, the new editor will be activated regardless.
// */
// // Close the old editor
// fActivePage.closeEditor(editor, false);
// // Ensure another editor in the stack is active
// fActivePage.activate(extra);
// callTrace.clear();
// // Verify that the editor is still activated
// IDE.openEditor(fActivePage, input, id, false);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
// assertEquals(callTrace.contains("partActivated"), true);
// }
//
// /**
// * tests both of the following: setEditorAreaVisible() isEditorAreaVisible()
// */
// public void testGet_SetEditorAreaVisible() throws Throwable {
// fActivePage.setEditorAreaVisible(true);
// assertTrue(fActivePage.isEditorAreaVisible() == true);
//
// fActivePage.setEditorAreaVisible(false);
// assertTrue(fActivePage.isEditorAreaVisible() == false);
// }
//
// /**
// * openEditor(IWorkbenchPage page, IFile input)
// */
// public void testOpenEditor() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
//
// /*
// * javadoc: 1. The workbench editor registry is consulted to determine
// * if an editor extension has been registered for the file type. If so,
// * an instance of the editor extension is opened on the file
// */
// IFile file = FileUtil.createFile("test.mock1", proj);
// IEditorPart editor = IDE.openEditor(fActivePage, file);
//
// boolean foundEditor = hasEditor(editor);
// assertEquals(foundEditor, true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(editor.getSite().getId(), fWorkbench.getEditorRegistry()
// .getDefaultEditor(file.getName()).getId());
//
// /*
// * javadoc: 2. Next, the native operating system will be consulted to
// * determine if a native editor exists for the file type. If so, a new
// * process is started and the native editor is opened on the file.
// */
// // can not be tested
// /*
// * javadoc: 3. If all else fails the file will be opened in a default
// * text editor.
// */
//
// file = FileUtil.createFile("a.null and void", proj);
// editor = IDE.openEditor(fActivePage, file);
// if (editor != null) {//If it opened an external editor skip it (Vista issue)
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(editor.getSite().getId(),
// "org.eclipse.ui.DefaultTextEditor");
//
// // open another editor to take the focus away from the first editor
// IDE
// .openEditor(fActivePage, FileUtil.createFile("test.mock2",
// proj));
//
// /*
// * javadoc: If this page already has an editor open on the target
// * object that editor is activated
// */
// // open the editor second time.
// assertEquals(editor, IDE.openEditor(fActivePage, file));
// assertEquals(editor, fActivePage.getActiveEditor());
// }
// }
//
// /**
// * openEditor(IWorkbenchPage page, IFile input, String editorID)
// */
// public void testOpenEditor2() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("asfasdasdf", proj);
// final String id = MockEditorPart.ID1;
//
// /*
// * javadoc: The editor type is determined by mapping editorId to an
// * editor extension registered with the workbench.
// */
// IEditorPart editor = IDE.openEditor(fActivePage, file, id);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
//
// // open another editor to take the focus away from the first editor
// IDE.openEditor(fActivePage, FileUtil.createFile("test.mock2", proj));
//
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is activated
// */
// // open the first editor second time.
// assertEquals(IDE.openEditor(fActivePage, file, id), editor);
// assertEquals(fActivePage.getActiveEditor(), editor);
// }
//
// /**
// * openEditor(IEditorInput input,String editorId)
// */
// public void testOpenEditor3() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final String id = MockEditorPart.ID1;
// IEditorInput input = new FileEditorInput(FileUtil.createFile(
// "test.mock1", proj));
//
// /*
// * javadoc: The editor type is determined by mapping editorId to an
// * editor extension registered with the workbench
// */
// IEditorPart editor = IDE.openEditor(fActivePage, input, id);
// assertEquals(editor.getEditorInput(), input);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
//
// // open another editor to take the focus away from the first editor
// IDE.openEditor(fActivePage, FileUtil.createFile("test.mock2", proj));
//
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is activated
// */
// // open the first editor second time.
// assertEquals(IDE.openEditor(fActivePage, input, id), editor);
// assertEquals(fActivePage.getActiveEditor(), editor);
// }
//
// /**
// * openEditor(IMarker marker)
// */
// public void testOpenEditor5() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// IMarker marker = FileUtil.createFile("aa.mock2", proj).createMarker(
// IMarker.TASK);
// CallHistory callTrace;
//
// /*
// * javadoc: the cursor and selection state of the editor is then updated
// * from information recorded in the marker.
// */
// // open the registered editor for the marker resource
// IEditorPart editor = IDE.openEditor(fActivePage, marker);
// callTrace = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID2);
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// /*
// * javadoc: If the marker contains an EDITOR_ID_ATTR attribute the
// * attribute value will be used to determine the editor type to be
// * opened
// */
// marker.setAttribute(IDE.EDITOR_ID_ATTR, MockEditorPart.ID1);
// editor = IDE.openEditor(fActivePage, marker);
// callTrace = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID1);
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("gotoMarker"), true);
// // do not close the editor this time
//
// /*
// * javdoc: If this page already has an editor open on the target object
// * that editor is activated
// */
// callTrace.clear();
// assertEquals(IDE.openEditor(fActivePage, marker), editor);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
// }
//
// /**
// * openEditor(IMarker marker, boolean activate)
// */
// public void testOpenEditor6() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// IMarker marker = FileUtil.createFile("aa.mock2", proj).createMarker(
// IMarker.TASK);
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// CallHistory listenerCall = listener.getCallHistory();
// CallHistory editorCall;
//
// // we need another editor so that the editor under test can receive
// // events.
// // otherwise, events will be ignored.
// IEditorPart extra = IDE.openEditor(fActivePage, FileUtil.createFile(
// "aaaaa", proj));
//
// /*
// * javadoc: If activate == true the editor will be activated
// */
// // open the registered editor for the marker resource with activation
// IEditorPart editor = IDE.openEditor(fActivePage, marker, true);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID2);
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
//
// /*
// * javadoc: the cursor and selection state of the editor is then updated
// * from information recorded in the marker.
// */
// assertEquals(editorCall.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// fActivePage.activate(extra);
//
// // open the registered editor for the marker resource without activation
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// listenerCall.clear();
// editor = IDE.openEditor(fActivePage, marker, false);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID2);
// assertEquals(hasEditor(editor), true);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// assertEquals(listenerCall.contains("partActivated"), false);
// assertEquals(editorCall.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// /*
// * javadoc: If the marker contains an EDITOR_ID_ATTR attribute the
// * attribute value will be used to determine the editor type to be
// * opened
// */
// String id = MockEditorPart.ID1;
// marker.setAttribute(IDE.EDITOR_ID_ATTR, id);
//
// // open an editor with activation
// listenerCall.clear();
//
// editor = IDE.openEditor(fActivePage, marker, true);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), id);
// assertEquals(hasEditor(editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(editorCall.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// fActivePage.activate(extra);
//
// // open an editor without activation
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// listenerCall.clear();
// editor = IDE.openEditor(fActivePage, marker, false);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), id);
// assertEquals(hasEditor(editor), true);
// assertEquals(editorCall.contains("gotoMarker"), true);
// assertEquals(listenerCall.contains("partActivated"), false);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// // do not close the editor this time
//
// fActivePage.activate(extra);
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is brought to front Note: we need to make a non-editor
// * active first or bringing the editor to front would activate it
// */
// // open the editor second time without activation
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// listenerCall.clear();
// assertEquals(IDE.openEditor(fActivePage, marker, false), editor);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// assertEquals(listenerCall.contains("partActivated"), false);
//
// fActivePage.activate(extra);
//
// /*
// * javdoc: If activate == true the editor will be activated
// */
// // open the editor second time with activation
// listenerCall.clear();
// assertEquals(IDE.openEditor(fActivePage, marker, true), editor);
// assertEquals(editorCall.contains("gotoMarker"), true);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// assertEquals(listenerCall.contains("partActivated"), true);
//
// /*
// * javadoc: If activate == false but another editor in the same stack
// * was active, the new editor will be activated regardless.
// */
// // Close the old editor
// fActivePage.closeEditor(editor, false);
// // Ensure another editor in the stack is active
// fActivePage.activate(extra);
// listenerCall.clear();
// // Verify that the editor is still activated
// IDE.openEditor(fActivePage, marker, false);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// assertEquals(listenerCall.contains("partActivated"), true);
// }
//
// public void testGetPerspective() throws Throwable {
// assertNotNull(fActivePage.getPerspective());
//
// IWorkbenchPage page = fWin.openPage(EmptyPerspective.PERSP_ID,
// getPageInput());
// assertEquals(EmptyPerspective.PERSP_ID, page.getPerspective().getId());
// }
//
// public void testSetPerspective() throws Throwable {
// IPerspectiveDescriptor per = PlatformUI.getWorkbench()
// .getPerspectiveRegistry().findPerspectiveWithId(
// EmptyPerspective.PERSP_ID);
// fActivePage.setPerspective(per);
// assertEquals(per, fActivePage.getPerspective());
// }
//
// public void testGetLabel() {
// assertNotNull(fActivePage.getLabel());
// }
//
// public void testGetInput() throws Throwable {
// IAdaptable input = getPageInput();
// IWorkbenchPage page = fWin.openPage(input);
// assertEquals(input, page.getInput());
// }
//
// public void testActivate() throws Throwable {
// MockViewPart part = (MockViewPart) fActivePage
// .showView(MockViewPart.ID);
// MockViewPart part2 = (MockViewPart) fActivePage
// .showView(MockViewPart.ID2);
//
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// fActivePage.activate(part);
//
// CallHistory callTrace;
//
// callTrace = part2.getCallHistory();
// callTrace.clear();
// fActivePage.activate(part2);
// assertTrue(callTrace.contains("setFocus"));
// assertTrue(listener.getCallHistory().contains("partActivated"));
//
// callTrace = part.getCallHistory();
// callTrace.clear();
// fActivePage.activate(part);
// assertTrue(callTrace.contains("setFocus"));
// assertTrue(listener.getCallHistory().contains("partActivated"));
// }
//
// public void testBringToTop() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// IEditorPart part = IDE.openEditor(fActivePage, FileUtil.createFile(
// "a.mock1", proj));
// IEditorPart part2 = IDE.openEditor(fActivePage, FileUtil.createFile(
// "b.mock1", proj));
//
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// CallHistory callTrace = listener.getCallHistory();
//
// // at this point, part2 is active
// fActivePage.bringToTop(part);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
//
// callTrace.clear();
// fActivePage.bringToTop(part2);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
// }
//
// public void testGetWorkbenchWindow() {
// /*
// * Commented out because until test case can be updated to work with new
// * window/page/perspective implementation
// *
// * assertEquals(fActivePage.getWorkbenchWindow(), fWin); IWorkbenchPage
// * page = openTestPage(fWin); assertEquals(page.getWorkbenchWindow(),
// * fWin);
// */
// }
//
// public void testShowView() throws Throwable {
// /*
// * javadoc: Shows a view in this page and give it focus
// */
// MockViewPart view = (MockViewPart) fActivePage
// .showView(MockViewPart.ID);
// assertNotNull(view);
// assertTrue(view.getCallHistory().verifyOrder(
// new String[] { "init", "createPartControl", "setFocus" }));
//
// fActivePage.showView(MockViewPart.ID2);
//
// /*
// * javadoc: If the view is already visible, it is given focus
// */
// CallHistory callTrace = view.getCallHistory();
// callTrace.clear();
// assertEquals(fActivePage.showView(MockViewPart.ID), view);
// assertEquals(callTrace.contains("setFocus"), true);
// }
//
// /**
// * Tests showing multi-instance views (docked normally).
// */
// public void testShowViewMult() throws Throwable {
// /*
// * javadoc: Shows the view identified by the given view id and secondary
// * id in this page and gives it focus. This allows multiple instances of
// * a particular view to be created. They are disambiguated using the
// * secondary id.
// */
// MockViewPart view = (MockViewPart) fActivePage
// .showView(MockViewPart.IDMULT);
// assertNotNull(view);
// assertTrue(view.getCallHistory().verifyOrder(
// new String[] { "init", "createPartControl", "setFocus" }));
// MockViewPart view2 = (MockViewPart) fActivePage.showView(
// MockViewPart.IDMULT, "2", IWorkbenchPage.VIEW_ACTIVATE);
// assertNotNull(view2);
// assertTrue(view2.getCallHistory().verifyOrder(
// new String[] { "init", "createPartControl", "setFocus" }));
// assertTrue(!view.equals(view2));
// MockViewPart view3 = (MockViewPart) fActivePage.showView(
// MockViewPart.IDMULT, "3", IWorkbenchPage.VIEW_ACTIVATE);
// assertNotNull(view3);
// assertTrue(view3.getCallHistory().verifyOrder(
// new String[] { "init", "createPartControl", "setFocus" }));
// assertTrue(!view.equals(view3));
// assertTrue(!view2.equals(view3));
//
// /*
// * javadoc: If there is a view identified by the given view id and
// * secondary id already open in this page, it is given focus.
// */
// CallHistory callTrace = view.getCallHistory();
// callTrace.clear();
// assertEquals(fActivePage.showView(MockViewPart.IDMULT), view);
// assertEquals(callTrace.contains("setFocus"), true);
// CallHistory callTrace2 = view2.getCallHistory();
// callTrace.clear();
// callTrace2.clear();
// assertEquals(fActivePage.showView(MockViewPart.IDMULT, "2",
// IWorkbenchPage.VIEW_ACTIVATE), view2);
// assertEquals(callTrace2.contains("setFocus"), true);
// assertEquals(callTrace.contains("setFocus"), false);
// CallHistory callTrace3 = view3.getCallHistory();
// callTrace.clear();
// callTrace2.clear();
// callTrace3.clear();
// assertEquals(fActivePage.showView(MockViewPart.IDMULT, "3",
// IWorkbenchPage.VIEW_ACTIVATE), view3);
// assertEquals(callTrace3.contains("setFocus"), true);
// assertEquals(callTrace.contains("setFocus"), false);
// assertEquals(callTrace2.contains("setFocus"), false);
//
// /*
// * javadoc: If a secondary id is given, the view must allow multiple
// * instances by having specified allowMultiple="true" in its extension.
// */
// boolean exceptionThrown = false;
// try {
// fActivePage.showView(MockViewPart.ID, "2",
// IWorkbenchPage.VIEW_ACTIVATE);
// } catch (PartInitException e) {
// assertEquals(e.getMessage().indexOf("mult") != -1, true);
// exceptionThrown = true;
// }
// assertEquals(exceptionThrown, true);
// }
//
// /**
// * Tests showing multi-instance views (as fast views). This is a regression
// * test for bug 76669 - [Perspectives] NullPointerException in
// * Perspective.getFastViewWidthRatio()
// */
// public void testShowViewMultFast() throws Throwable {
// /*
// * javadoc: Shows the view identified by the given view id and secondary
// * id in this page and gives it focus. This allows multiple instances of
// * a particular view to be created. They are disambiguated using the
// * secondary id.
// */
// MockViewPart view = (MockViewPart) fActivePage
// .showView(MockViewPart.IDMULT);
// assertNotNull(view);
// assertTrue(view.getCallHistory().verifyOrder(
// new String[] { "init", "createPartControl", "setFocus" }));
// MockViewPart view2 = (MockViewPart) fActivePage.showView(
// MockViewPart.IDMULT, "2", IWorkbenchPage.VIEW_ACTIVATE);
// assertNotNull(view2);
// assertTrue(view2.getCallHistory().verifyOrder(
// new String[] { "init", "createPartControl", "setFocus" }));
// assertTrue(!view.equals(view2));
//
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// IViewReference ref = (IViewReference) page.getReference(view);
// IViewReference ref2 = (IViewReference) page.getReference(view2);
// page.addFastView(ref);
// page.addFastView(ref2);
//
// page.activate(view);
// assertEquals(view, page.getActivePart());
//
// page.activate(view2);
// assertEquals(view2, page.getActivePart());
// }
//
// /**
// * Tests saving the page state when there is a fast view that is also a
// * multi-instance view. This is a regression test for bug 76669 -
// * [Perspectives] NullPointerException in
// * Perspective.getFastViewWidthRatio()
// */
// public void testBug76669() throws Throwable {
// MockViewPart view = (MockViewPart) fActivePage
// .showView(MockViewPart.IDMULT);
// MockViewPart view2 = (MockViewPart) fActivePage.showView(
// MockViewPart.IDMULT, "2", IWorkbenchPage.VIEW_ACTIVATE);
//
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// IViewReference ref = (IViewReference) page.getReference(view);
// IViewReference ref2 = (IViewReference) page.getReference(view2);
// page.addFastView(ref);
// page.addFastView(ref2);
//
// IMemento memento = XMLMemento.createWriteRoot("page");
// page.saveState(memento);
// IMemento persps = memento.getChild("perspectives");
// IMemento persp = persps.getChildren("perspective")[0];
// IMemento[] fastViews = persp.getChild("fastViews").getChildren("view");
// assertEquals(2, fastViews.length);
// }
//
// public void testFindView() throws Throwable {
// String id = MockViewPart.ID3;
// // id of valid, but not open view
// assertNull(fActivePage.findView(id));
//
// IViewPart view = fActivePage.showView(id);
// assertEquals(fActivePage.findView(id), view);
//
// // close view
// fActivePage.hideView(view);
// assertNull(fActivePage.findView(id));
// }
//
// public void testFindViewReference() throws Throwable {
// fActivePage.getWorkbenchWindow().getWorkbench().showPerspective(
// SessionPerspective.ID, fActivePage.getWorkbenchWindow());
// assertNull(fActivePage.findViewReference(MockViewPart.ID4));
//
// fActivePage.showView(MockViewPart.ID4);
// assertNotNull(fActivePage.findViewReference(MockViewPart.ID4));
// }
//
// public void testGetViews() throws Throwable {
// int totalBefore = fActivePage.getViewReferences().length;
//
// IViewPart view = fActivePage.showView(MockViewPart.ID2);
// assertEquals(hasView(view), true);
// assertEquals(fActivePage.getViewReferences().length, totalBefore + 1);
//
// fActivePage.hideView(view);
// assertEquals(hasView(view), false);
// assertEquals(fActivePage.getViewReferences().length, totalBefore);
// }
//
// public void testHideViewWithPart() throws Throwable {
// // test that nothing bad happens with a null parameter
// try {
// fActivePage.hideView((IViewPart) null);
// } catch (RuntimeException e) {
// fail(e.getMessage());
// }
//
// IViewPart view = fActivePage.showView(MockViewPart.ID3);
//
// fActivePage.hideView(view);
// CallHistory callTrace = ((MockViewPart) view).getCallHistory();
// assertTrue(callTrace.contains("dispose"));
// }
//
// public void testHideViewWithReference() throws Throwable {
// // test that nothing bad happens with a null parameter
// try {
// fActivePage.hideView((IViewReference) null);
// } catch (RuntimeException e) {
// fail(e.getMessage());
// }
//
// IViewPart view = fActivePage.showView(MockViewPart.ID4);
// IViewReference ref = fActivePage.findViewReference(MockViewPart.ID4);
// fActivePage.hideView(ref);
// CallHistory callTrace = ((MockViewPart) view).getCallHistory();
// assertTrue(callTrace.contains("dispose"));
//
// }
//
// public void testHideSaveableView() throws Throwable {
// String viewId = SaveableMockViewPart.ID;
// SaveableMockViewPart view = (SaveableMockViewPart) fActivePage
// .showView(viewId);
// fActivePage.hideView(view);
// CallHistory callTrace = view.getCallHistory();
// assertTrue(callTrace.contains("isDirty"));
// assertTrue(callTrace.contains("dispose"));
// assertEquals(fActivePage.findView(viewId), null);
//
// try {
// SaveableHelper.testSetAutomatedResponse(1); // No
// view = (SaveableMockViewPart) fActivePage.showView(viewId);
// view.setDirty(true);
// fActivePage.hideView(view);
// callTrace = view.getCallHistory();
// assertTrue(callTrace.contains("isDirty"));
// assertFalse(callTrace.contains("doSave"));
// assertTrue(callTrace.contains("dispose"));
// assertEquals(fActivePage.findView(viewId), null);
//
// SaveableHelper.testSetAutomatedResponse(2); // Cancel
// view = (SaveableMockViewPart) fActivePage.showView(viewId);
// view.setDirty(true);
// fActivePage.hideView(view);
// callTrace = view.getCallHistory();
// assertTrue(callTrace.contains("isDirty"));
// assertFalse(callTrace.contains("doSave"));
// assertFalse(callTrace.contains("dispose"));
// assertEquals(fActivePage.findView(viewId), view);
//
// SaveableHelper.testSetAutomatedResponse(0); // Yes
// view = (SaveableMockViewPart) fActivePage.showView(viewId);
// view.setDirty(true);
// fActivePage.hideView(view);
// callTrace = view.getCallHistory();
// assertTrue(callTrace.contains("isDirty"));
// assertTrue(callTrace.contains("doSave"));
// assertTrue(callTrace.contains("dispose"));
// assertEquals(fActivePage.findView(viewId), null);
//
// // don't leave the view showing, or the UI will block on window
// // close
// } finally {
// SaveableHelper.testSetAutomatedResponse(-1); // restore default
// // (prompt)
// }
// }
//
// /**
// * Tests that a close will fall back to the default if the view returns
// * ISaveable2.DEFAULT.
// *
// * @throws Throwable
// */
// public void testCloseWithSaveNeeded() throws Throwable {
// String viewId = UserSaveableMockViewPart.ID;
// UserSaveableMockViewPart view = (UserSaveableMockViewPart) fActivePage
// .showView(viewId);
// fActivePage.hideView(view);
//
// UserSaveableMockViewPart view2 = null;
//
// CallHistory callTrace = view.getCallHistory();
// assertTrue(callTrace.contains("isDirty"));
// assertTrue(callTrace.contains("dispose"));
// assertEquals(fActivePage.findView(UserSaveableMockViewPart.ID), null);
//
// try {
// SaveableHelper.testSetAutomatedResponse(3); // DEFAULT
// view = (UserSaveableMockViewPart) fActivePage.showView(viewId);
// view.setDirty(true);
// view2 = (UserSaveableMockViewPart) fActivePage.showView(viewId,
// "2", IWorkbenchPage.VIEW_ACTIVATE);
// assertNotNull(view2);
// view2.setDirty(true);
//
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// page.getEditorManager().saveAll(true, false, false);
//
// assertFalse(view.isDirty());
// assertFalse(view2.isDirty());
//
// callTrace = view.getCallHistory();
// fActivePage.hideView(view);
// fActivePage.hideView(view2);
//
// assertTrue(callTrace.contains("isDirty"));
// assertTrue(callTrace.contains("doSave"));
// assertEquals(fActivePage.findView(viewId), null);
//
// // don't leave the view showing, or the UI will block on window
// // close
// } finally {
// SaveableHelper
// .testSetAutomatedResponse(SaveableHelper.USER_RESPONSE); // restore
// // default
// // (prompt)
// }
// }
//
// /**
// * Tests that a close will fall back to the default if the view returns
// * ISaveable2.DEFAULT.
// *
// * @throws Throwable
// */
// public void testSaveEffectsSharedModel() throws Throwable {
// String viewId = UserSaveableSharedViewPart.ID;
// UserSaveableSharedViewPart view = null;
//
// UserSaveableSharedViewPart view2 = null;
//
// assertEquals(fActivePage.findView(UserSaveableSharedViewPart.ID), null);
//
// try {
// SaveableHelper.testSetAutomatedResponse(3); // DEFAULT
// UserSaveableSharedViewPart.SharedModel model = new UserSaveableSharedViewPart.SharedModel();
// view = (UserSaveableSharedViewPart) fActivePage.showView(viewId);
// view.setSharedModel(model);
//
// view2 = (UserSaveableSharedViewPart) fActivePage.showView(viewId,
// "2", IWorkbenchPage.VIEW_ACTIVATE);
// assertNotNull(view2);
// view2.setSharedModel(model);
//
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// page.getEditorManager().saveAll(true, false, false);
//
// assertFalse(view.isDirty());
// assertFalse(view2.isDirty());
//
// CallHistory callTrace = view.getCallHistory();
// CallHistory call2 = view2.getCallHistory();
//
// assertTrue(callTrace.contains("isDirty"));
// assertTrue(call2.contains("isDirty"));
// assertTrue("At least one should call doSave", callTrace
// .contains("doSave")
// || call2.contains("doSave"));
// assertFalse("Both should not call doSave", callTrace
// .contains("doSave")
// && call2.contains("doSave"));
//
// // don't leave the view showing, or the UI will block on window
// // close
// } finally {
// SaveableHelper
// .testSetAutomatedResponse(SaveableHelper.USER_RESPONSE); // restore
// // default
// // (prompt)
// fActivePage.hideView(view);
// fActivePage.hideView(view2);
// }
// }
//
// public void testClose() throws Throwable {
// IWorkbenchPage page = openTestPage(fWin);
//
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("aaa.mock1", proj);
// IEditorPart editor = IDE.openEditor(page, file);
// CallHistory callTrace = ((MockEditorPart) editor).getCallHistory();
// callTrace.clear();
//
// /*
// * javadoc: If the page has open editors with unsaved content and save
// * is true, the user will be given the opportunity to save them
// */
// assertEquals(page.close(), true);
// assertEquals(callTrace
// .verifyOrder(new String[] { "isDirty", "dispose" }), true);
// assertEquals(fWin.getActivePage(), fActivePage);
// }
//
// public void testCloseEditor() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("test.mock1", proj);
// IEditorPart editor;
// CallHistory callTrace;
// MockEditorPart mock;
//
// /*
// * javadoc: Parameters: save - true to save the editor contents if
// * required (recommended)
// */
// // create a clean editor that needs to be saved on closing
// editor = IDE.openEditor(fActivePage, file);
// mock = (MockEditorPart) editor;
// mock.setSaveNeeded(true);
// callTrace = mock.getCallHistory();
// callTrace.clear();
// // close the editor with save confirmation
// assertEquals(fActivePage.closeEditor(editor, true), true);
// assertEquals(callTrace
// .verifyOrder(new String[] { "isDirty", "dispose" }), true);
//
// /*
// * javadoc: If the editor has unsaved content and save is true, the user
// * will be given the opportunity to save it.
// */
// // can't be tested
// /*
// * javadoc: Parameters: save - false to discard any unsaved changes
// */
// // create a dirty editor
// editor = IDE.openEditor(fActivePage, file);
// mock = (MockEditorPart) editor;
// mock.setDirty(true);
// mock.setSaveNeeded(true);
// callTrace = mock.getCallHistory();
// callTrace.clear();
// // close the editor and discard changes
// assertEquals(fActivePage.closeEditor(editor, false), true);
// assertEquals(callTrace.contains("isSaveOnCloseNeeded"), false);
// /*
// * It is possible that some action may query the isDirty value of the
// * editor to update its enabled state. There is nothing wrong in doing
// * that, so do not test for no isDirty call here.
// *
// * assertEquals(callTrace.contains( "isDirty"), false);
// */
// assertEquals(callTrace.contains("doSave"), false);
// assertEquals(callTrace.contains("dispose"), true);
// }
//
// public void testCloseEditors() throws Throwable {
// int total = 5;
// final IFile[] files = new IFile[total];
// IEditorPart[] editors = new IEditorPart[total];
// IEditorReference[] editorRefs = new IEditorReference[total];
// CallHistory[] callTraces = new CallHistory[total];
// MockEditorPart[] mocks = new MockEditorPart[total];
//
// proj = FileUtil.createProject("testCloseEditors");
// for (int i = 0; i < total; i++)
// files[i] = FileUtil.createFile(i + ".mock2", proj);
//
// /*
// * javadoc: If the page has open editors with unsaved content and save
// * is true, the user will be given the opportunity to save them.
// */
// // close all clean editors with confirmation
// for (int i = 0; i < total; i++) {
// editors[i] = IDE.openEditor(fActivePage, files[i]);
// callTraces[i] = ((MockEditorPart) editors[i]).getCallHistory();
// }
//
// editorRefs = fActivePage.getEditorReferences();
// assertEquals(fActivePage.closeEditors(editorRefs, true), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // close all dirty editors with confirmation
// // can't be tested
//
// // close all dirty editors discarding them
// for (int i = 0; i < total; i++) {
// editors[i] = IDE.openEditor(fActivePage, files[i]);
// mocks[i] = (MockEditorPart) editors[i];
// mocks[i].setDirty(true);
// callTraces[i] = mocks[i].getCallHistory();
// }
// editorRefs = fActivePage.getEditorReferences();
// assertEquals(fActivePage.closeEditors(editorRefs, false), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("doSave"), false);
// }
//
// // close empty array of editors
// total = 1;
// for (int i = 0; i < total; i++) {
// editors[i] = IDE.openEditor(fActivePage, files[i]);
// mocks[i] = (MockEditorPart) editors[i];
// mocks[i].setDirty(true);
// callTraces[i] = mocks[i].getCallHistory();
// }
// // empty array test
// editorRefs = new IEditorReference[0];
// assertEquals(fActivePage.closeEditors(editorRefs, true), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // close the last remaining editor, with save=false
// editorRefs = fActivePage.getEditorReferences();
// fActivePage.closeEditors(editorRefs, false);
// }
//
// public void testCloseAllEditors() throws Throwable {
// int total = 5;
// final IFile[] files = new IFile[total];
// IEditorPart[] editors = new IEditorPart[total];
// CallHistory[] callTraces = new CallHistory[total];
// MockEditorPart[] mocks = new MockEditorPart[total];
//
// proj = FileUtil.createProject("testOpenEditor");
// for (int i = 0; i < total; i++)
// files[i] = FileUtil.createFile(i + ".mock2", proj);
//
// /*
// * javadoc: If the page has open editors with unsaved content and save
// * is true, the user will be given the opportunity to save them.
// */
// // close all clean editors with confirmation
// for (int i = 0; i < total; i++) {
// editors[i] = IDE.openEditor(fActivePage, files[i]);
// callTraces[i] = ((MockEditorPart) editors[i]).getCallHistory();
// }
// assertEquals(fActivePage.closeAllEditors(true), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // close all dirty editors with confirmation
// // can't be tested
//
// // close all dirty editors discarding them
// for (int i = 0; i < total; i++) {
// editors[i] = IDE.openEditor(fActivePage, files[i]);
// mocks[i] = (MockEditorPart) editors[i];
// mocks[i].setDirty(true);
// callTraces[i] = mocks[i].getCallHistory();
// }
// assertEquals(fActivePage.closeAllEditors(false), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("doSave"), false);
// }
// }
//
// public void testSaveEditor() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("test.mock1", proj);
// IEditorPart editor;
// CallHistory callTrace;
// MockEditorPart mock;
//
// // create a clean editor
// editor = IDE.openEditor(fActivePage, file);
// mock = (MockEditorPart) editor;
// callTrace = mock.getCallHistory();
// callTrace.clear();
//
// /*
// * javadoc: Saves the contents of the given editor if dirty. If not,
// * this method returns without effect
// */
// // save the clean editor with confirmation
// assertEquals(fActivePage.saveEditor(editor, true), true);
// assertEquals(callTrace.contains("isDirty"), true);
// assertEquals(callTrace.contains("doSave"), false);
//
// /*
// * javadoc: If confirm is true the user is prompted to confirm the
// * command.
// */
// // can't be tested
// /*
// * javadoc: Otherwise, the save happens without prompt.
// */
// // save the clean editor without confirmation
// assertEquals(fActivePage.saveEditor(editor, false), true);
// assertEquals(callTrace.contains("isDirty"), true);
// assertEquals(callTrace.contains("doSave"), false);
//
// // save the dirty editor without confirmation
// mock.setDirty(true);
// callTrace.clear();
// assertEquals(fActivePage.saveEditor(editor, false), true);
// assertEquals(callTrace
// .verifyOrder(new String[] { "isDirty", "doSave" }), true);
// }
//
// public void testIDESaveAllEditors() throws Throwable {
// int total = 3;
//
// final IFile[] files = new IFile[total];
// IEditorPart[] editors = new IEditorPart[total];
// CallHistory[] callTraces = new CallHistory[total];
// MockEditorPart[] mocks = new MockEditorPart[total];
//
// proj = FileUtil.createProject("testOpenEditor");
// for (int i = 0; i < total; i++) {
// files[i] = FileUtil.createFile(i + ".mock2", proj);
// editors[i] = IDE.openEditor(fActivePage, files[i]);
// mocks[i] = (MockEditorPart) editors[i];
// callTraces[i] = mocks[i].getCallHistory();
// }
//
// /*
// * javadoc: If there are no dirty editors this method returns without
// * effect. javadoc: If confirm is true the user is prompted to confirm
// * the command
// */
// // save all clean editors with confirmation
// assertEquals(IDE.saveAllEditors(new IResource[] { proj }, true), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // save all dirty editors with confirmation can't be tested
//
// /*
// * javadoc: Parameters: confirm - false to save unsaved changes without
// * asking
// */
// // save all clean editors without confirmation
// assertEquals(IDE.saveAllEditors(new IResource[] { proj }, false), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // save all dirty editors with resource that IS NOT a parent
// // of the contents of the dirty editors without confirmation, this
// // should not
// // save any as they are not parented by the resource provided
// for (int i = 0; i < total; i++)
// mocks[i].setDirty(true);
//
// IResource emptyProj = FileUtil
// .createProject("testOpenEditorEmptyProject");
// assertEquals(IDE.saveAllEditors(new IResource[] { emptyProj }, false),
// true);
// for (int i = 0; i < total; i++) {
// // the editors were not in the empty project hence still dirty
// assertEquals(mocks[i].isDirty(), true);
// callTraces[i].clear();
// }
//
// // save all dirty editors with resource that IS a parent
// // of the contents of the editors without confirmation, this should
// // save them as they are parented by the resource provided
// assertEquals(IDE.saveAllEditors(new IResource[] { proj }, false), true);
// for (int i = 0; i < total; i++) {
// // the editors were not in the empty project hence still dirty
// assertEquals(mocks[i].isDirty(), false);
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), true);
// callTraces[i].clear();
// }
//
// // save all dirty editors with resource that IS NOT a parent
// // of the contents of the dirty editors without confirmation, this
// // should not
// // save any as they are not parented by the resource provided
// for (int i = 0; i < total; i++)
// mocks[i].setDirty(true);
// assertEquals(IDE.saveAllEditors(new IResource[] {}, false), true);
// for (int i = 0; i < total; i++) {
// // the editors were not in the empty project hence still dirty
// assertEquals(mocks[i].isDirty(), true);
// callTraces[i].clear();
// }
//
// // clear the dirty state so the tearDown does not open a confirm dialog.
// for (int i = 0; i < total; i++)
// mocks[i].setDirty(false);
// }
//
// public void testSaveAllEditors() throws Throwable {
// int total = 3;
//
// final IFile[] files = new IFile[total];
// IEditorPart[] editors = new IEditorPart[total];
// CallHistory[] callTraces = new CallHistory[total];
// MockEditorPart[] mocks = new MockEditorPart[total];
//
// proj = FileUtil.createProject("testOpenEditor");
// for (int i = 0; i < total; i++) {
// files[i] = FileUtil.createFile(i + ".mock2", proj);
// editors[i] = IDE.openEditor(fActivePage, files[i]);
// mocks[i] = (MockEditorPart) editors[i];
// callTraces[i] = mocks[i].getCallHistory();
// }
//
// /*
// * javadoc: If there are no dirty editors this method returns without
// * effect. javadoc: If confirm is true the user is prompted to confirm
// * the command
// */
// // save all clean editors with confirmation
// assertEquals(fActivePage.saveAllEditors(true), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // save all dirty editors with confirmation can't be tested
//
// /*
// * javadoc: Parameters: confirm - false to save unsaved changes without
// * asking
// */
// // save all clean editors without confirmation
// assertEquals(fActivePage.saveAllEditors(false), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // save all dirty editors without confirmation
// for (int i = 0; i < total; i++)
// mocks[i].setDirty(true);
// assertEquals(fActivePage.saveAllEditors(false), true);
// for (int i = 0; i < total; i++)
// assertEquals(callTraces[i].verifyOrder(new String[] { "isDirty",
// "doSave" }), true);
// }
//
// public void testGetEditors() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// int totalBefore = fActivePage.getEditorReferences().length;
// int num = 3;
// IEditorPart[] editors = new IEditorPart[num];
//
// for (int i = 0; i < num; i++) {
// editors[i] = IDE.openEditor(fActivePage, FileUtil.createFile(i
// + ".mock2", proj));
// assertEquals(hasEditor(editors[i]), true);
// }
// assertEquals(fActivePage.getEditorReferences().length, totalBefore
// + num);
//
// fActivePage.closeEditor(editors[0], false);
// assertEquals(hasEditor(editors[0]), false);
// assertEquals(fActivePage.getEditorReferences().length, totalBefore
// + num - 1);
//
// fActivePage.closeAllEditors(false);
// assertEquals(fActivePage.getEditorReferences().length, 0);
// }
//
// public void testShowActionSet() {
// String id = MockActionDelegate.ACTION_SET_ID;
// WorkbenchPage page = (WorkbenchPage) fActivePage;
//
// int totalBefore = page.getActionSets().length;
// fActivePage.showActionSet(id);
//
// IActionSetDescriptor[] sets = ((WorkbenchPage) fActivePage)
// .getActionSets();
// boolean found = false;
// for (int i = 0; i < sets.length; i++)
// if (id.equals(sets[i].getId()))
// found = true;
// assertEquals(found, true);
//
// // check that the method does not add an invalid action set to itself
// id = IConstants.FakeID;
// fActivePage.showActionSet(id);
//
// sets = ((WorkbenchPage) fActivePage).getActionSets();
// found = false;
// for (int i = 0; i < sets.length; i++)
// if (id.equals(sets[i].getId()))
// found = true;
// assertEquals(found, false);
// assertEquals(page.getActionSets().length, totalBefore + 1);
// }
//
// public void testHideActionSet() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// int totalBefore = page.getActionSets().length;
//
// String id = MockWorkbenchWindowActionDelegate.SET_ID;
// fActivePage.showActionSet(id);
// assertEquals(page.getActionSets().length, totalBefore + 1);
//
// fActivePage.hideActionSet(id);
// assertEquals(page.getActionSets().length, totalBefore);
//
// IActionSetDescriptor[] sets = page.getActionSets();
// boolean found = false;
// for (int i = 0; i < sets.length; i++)
// if (id.equals(sets[i].getId()))
// found = true;
// assertEquals(found, false);
// }
//
// /**
// * Return whether or not the editor exists in the current page.
// *
// * @param editor
// * @return boolean
// */
// private boolean hasEditor(IEditorPart editor) {
// IEditorReference[] references = fActivePage.getEditorReferences();
// for (int i = 0; i < references.length; i++) {
// if (references[i].getEditor(false).equals(editor))
// return true;
// }
// return false;
// }
//
// /**
// * Return whether or not the view exists in the current page.
// *
// * @param editor
// * @return boolean
// */
// private boolean hasView(IViewPart view) {
// IViewReference[] references = fActivePage.getViewReferences();
// for (int i = 0; i < references.length; i++) {
// if (references[i].getView(false).equals(view))
// return true;
// }
// return false;
// }
//
// public void testStackOrder() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// try {
// IViewPart part1 = page.showView(MockViewPart.ID);
// IViewPart part2 = page.showView(MockViewPart.ID2);
// IViewPart part3 = page.showView(MockViewPart.ID3);
// IViewPart part4 = page.showView(MockViewPart.ID4);
//
// IViewPart[] stack = page.getViewStack(part1);
// assertTrue(stack.length == 4);
// assertTrue(stack[0] == part4);
// assertTrue(stack[1] == part3);
// assertTrue(stack[2] == part2);
// assertTrue(stack[3] == part1);
//
// page.activate(part2);
// stack = page.getViewStack(part1);
// assertTrue(stack.length == 4);
// assertTrue(stack[0] == part2);
// assertTrue(stack[1] == part4);
// assertTrue(stack[2] == part3);
// assertTrue(stack[3] == part1);
//
// page.activate(part1);
// stack = page.getViewStack(part1);
// assertTrue(stack.length == 4);
// assertTrue(stack[0] == part1);
// assertTrue(stack[1] == part2);
// assertTrue(stack[2] == part4);
// assertTrue(stack[3] == part3);
//
// page.activate(part3);
// stack = page.getViewStack(part1);
// assertTrue(stack.length == 4);
// assertTrue(stack[0] == part3);
// assertTrue(stack[1] == part1);
// assertTrue(stack[2] == part2);
// assertTrue(stack[3] == part4);
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
//
// /**
// * Test the VIEW_CREATE parameter for showView. Ensures that the created
// * view is not the active part.
// *
// */
// public void testView_CREATE1() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// try {
//
// page.setPerspective(WorkbenchPlugin.getDefault()
// .getPerspectiveRegistry().findPerspectiveWithId(
// "org.eclipse.ui.tests.api.ViewPerspective"));
//
// // create a part to be active
// IViewPart activePart = page.showView(MockViewPart.ID);
// IViewPart createdPart = page.showView(MockViewPart.ID2, null,
// IWorkbenchPage.VIEW_CREATE);
//
// IViewPart[] stack = page.getViewStack(activePart);
// assertEquals(2, stack.length);
//
// assertEquals(activePart, stack[0]);
// assertEquals(createdPart, stack[1]);
//
// assertFalse(page.isPartVisible(createdPart));
//
// assertEquals(activePart, page.getActivePart());
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
//
// /**
// * Test the VIEW_CREATE parameter for showView. Ensures that the created
// * view is not the active part and is not visible
// */
// public void testView_CREATE2() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// try {
//
// page.setPerspective(WorkbenchPlugin.getDefault()
// .getPerspectiveRegistry().findPerspectiveWithId(
// "org.eclipse.ui.tests.api.ViewPerspective"));
//
// // create a part to be active
// IViewPart activePart = page.showView(MockViewPart.ID3);
// IViewPart createdPart = page.showView(MockViewPart.ID2, null,
// IWorkbenchPage.VIEW_CREATE);
//
// IViewPart[] stack = page.getViewStack(createdPart);
// assertEquals(2, stack.length);
//
// assertEquals(page.findView(MockViewPart.ID), stack[0]);
// assertEquals(createdPart, stack[1]);
//
// assertFalse(page.isPartVisible(createdPart));
//
// assertEquals(activePart, page.getActivePart());
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
//
// /**
// * Test the VIEW_CREATE parameter for showView. Ensures that the created
// * view is not the active part and is visible.
// */
// public void testView_CREATE3() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// try {
//
// page.setPerspective(WorkbenchPlugin.getDefault()
// .getPerspectiveRegistry().findPerspectiveWithId(
// "org.eclipse.ui.tests.api.ViewPerspective"));
//
// // create a part to be active
// IViewPart activePart = page.showView(MockViewPart.ID3);
// IViewPart createdPart = page.showView(MockViewPart.ID4, null,
// IWorkbenchPage.VIEW_CREATE);
//
// IViewPart[] stack = page.getViewStack(createdPart);
// assertEquals(1, stack.length);
//
// assertEquals(createdPart, stack[0]);
//
// assertTrue(page.isPartVisible(createdPart));
//
// assertEquals(activePart, page.getActivePart());
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
//
// /**
// * Test the VIEW_VISIBLE parameter for showView, opening the view in the
// * stack containing the active view. Ensures that the created view is not
// * the active part and is not visible.
// */
// public void testView_VISIBLE1() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// try {
// page.setPerspective(WorkbenchPlugin.getDefault()
// .getPerspectiveRegistry().findPerspectiveWithId(
// "org.eclipse.ui.tests.api.ViewPerspective"));
//
// // create a part to be active
// IViewPart activePart = page.showView(MockViewPart.ID);
// IViewPart createdPart = page.showView(MockViewPart.ID2, null,
// IWorkbenchPage.VIEW_VISIBLE);
// IViewPart[] stack = page.getViewStack(activePart);
// assertEquals(2, stack.length);
//
// assertEquals(activePart, stack[0]);
// assertEquals(createdPart, stack[1]);
//
// assertFalse(page.isPartVisible(createdPart));
//
// assertEquals(activePart, page.getActivePart());
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
//
// /**
// * Test the VIEW_VISIBLE parameter for showView, opening the view in its own
// * stack. Ensures that the created view is not active part but is the top
// * part in its stack.
// */
// public void testView_VISIBLE3() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// try {
// page.setPerspective(WorkbenchPlugin.getDefault()
// .getPerspectiveRegistry().findPerspectiveWithId(
// "org.eclipse.ui.tests.api.ViewPerspective"));
//
// // create a part to be active
// IViewPart activePart = page.showView(MockViewPart.ID3);
//
// IViewPart createdPart = page.showView(MockViewPart.ID4, null,
// IWorkbenchPage.VIEW_VISIBLE);
// IViewPart[] stack = page.getViewStack(createdPart);
// assertEquals(1, stack.length);
//
// assertEquals(createdPart, stack[0]);
//
// assertTrue(page.isPartVisible(createdPart));
//
// assertEquals(activePart, page.getActivePart());
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
//
// /**
// * Test opening a perspective with a fast view.
// */
// public void testOpenPerspectiveWithFastView() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
//
// try {
// fWin.getWorkbench().showPerspective(
// PerspectiveWithFastView.PERSP_ID, fWin);
// } catch (WorkbenchException e) {
// fail("Unexpected WorkbenchException: " + e);
// }
//
// assertEquals(page.getFastViews().length, 1);
// assertEquals(page.getFastViews()[0].getId(),
// "org.eclipse.ui.views.ResourceNavigator");
// assertEquals(page.getViewReferences().length, 1);
// assertTrue(page.getViewReferences()[0].isFastView());
//
// IPerspectiveDescriptor persp = page.getPerspective();
//
// ICommandService commandService = (ICommandService) fWorkbench.getService(ICommandService.class);
// Command command = commandService.getCommand("org.eclipse.ui.window.closePerspective");
//
// HashMap parameters = new HashMap();
// parameters.put("org.eclipse.ui.window.closePerspective.perspectiveId", persp.getId());
//
// ParameterizedCommand pCommand = ParameterizedCommand.generateCommand(command, parameters);
//
// IHandlerService handlerService = (IHandlerService) fWorkbench
// .getService(IHandlerService.class);
// try {
// handlerService.executeCommand(pCommand, null);
// } catch (ExecutionException e1) {
// } catch (NotDefinedException e1) {
// } catch (NotEnabledException e1) {
// } catch (NotHandledException e1) {
// }
//
// }
//
// /**
// * Test opening a perspective with placeholders for multi instance views.
// * The placeholders are added at top level (not in any folder).
// *
// * @since 3.1
// */
// public void testOpenPerspectiveWithMultiViewPlaceholdersAtTopLevel() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
//
// try {
// fWin.getWorkbench().showPerspective(
// PerspectiveWithMultiViewPlaceholdersAtTopLevel.PERSP_ID,
// fWin);
// } catch (WorkbenchException e) {
// fail("Unexpected WorkbenchException: " + e);
// }
//
// PerspectiveState state = new PerspectiveState(page);
// ArrayList partIds = state.getPartIds(null);
// assertTrue(partIds.contains("*"));
// assertTrue(partIds.contains(MockViewPart.IDMULT));
// assertTrue(partIds.contains(MockViewPart.IDMULT + ":secondaryId"));
// assertTrue(partIds.contains(MockViewPart.IDMULT + ":*"));
// }
//
// /**
// * Test opening a perspective with placeholders for multi instance views.
// * The placeholders are added in a placeholder folder. This is a regression
// * test for bug 72383 [Perspectives] Placeholder folder error with multiple
// * instance views
// *
// * @since 3.1
// */
// public void testOpenPerspectiveWithMultiViewPlaceholdersInPlaceholderFolder() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
//
// try {
// fWin
// .getWorkbench()
// .showPerspective(
// PerspectiveWithMultiViewPlaceholdersInPlaceholderFolder.PERSP_ID,
// fWin);
// } catch (WorkbenchException e) {
// fail("Unexpected WorkbenchException: " + e);
// }
//
// PerspectiveState state = new PerspectiveState(page);
// ArrayList partIds = state.getPartIds("placeholderFolder");
// assertTrue(partIds.contains("*"));
// assertTrue(partIds.contains(MockViewPart.IDMULT));
// assertTrue(partIds.contains(MockViewPart.IDMULT + ":secondaryId"));
// assertTrue(partIds.contains(MockViewPart.IDMULT + ":*"));
// }
//
// /**
// * Test opening a perspective with placeholders for multi instance views.
// * The placeholders are added at top level (not in any folder).
// *
// * @since 3.1
// */
// public void testOpenPerspectiveWithMultiViewPlaceholdersInFolder() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
//
// try {
// fWin
// .getWorkbench()
// .showPerspective(
// PerspectiveWithMultiViewPlaceholdersInFolder.PERSP_ID,
// fWin);
// } catch (WorkbenchException e) {
// fail("Unexpected WorkbenchException: " + e);
// }
//
// PerspectiveState state = new PerspectiveState(page);
// ArrayList partIds = state.getPartIds("folder");
// assertTrue(partIds.contains("*"));
// assertTrue(partIds.contains(MockViewPart.IDMULT));
// assertTrue(partIds.contains(MockViewPart.IDMULT + ":secondaryId"));
// assertTrue(partIds.contains(MockViewPart.IDMULT + ":*"));
// }
//
// /**
// * Tests the getNewWizardShortcuts() method.
// *
// * @since 3.1
// */
// public void testGetNewWizardShortcuts() {
// String[] shortcuts = fActivePage.getNewWizardShortcuts();
// assertNotNull(shortcuts);
// assertEquals(0, shortcuts.length);
//
// IWorkbenchWindow win = openTestWindow(IDE.RESOURCE_PERSPECTIVE_ID);
// IWorkbenchPage page = win.getActivePage();
// shortcuts = page.getNewWizardShortcuts();
// List shortcutList = Arrays.asList(shortcuts);
// assertTrue(shortcutList.contains("org.eclipse.ui.wizards.new.folder"));
// assertTrue(shortcutList.contains("org.eclipse.ui.wizards.new.file"));
// }
//
// /**
// * Tests the getShowViewShortcuts() method.
// *
// * @since 3.1
// */
// public void testGetShowViewShortcuts() {
// String[] shortcuts = fActivePage.getShowViewShortcuts();
// assertNotNull(shortcuts);
// assertEquals(0, shortcuts.length);
//
// IWorkbenchWindow win = openTestWindow(IDE.RESOURCE_PERSPECTIVE_ID);
// IWorkbenchPage page = win.getActivePage();
// shortcuts = page.getShowViewShortcuts();
// List shortcutList = Arrays.asList(shortcuts);
// assertTrue(shortcutList.contains(IPageLayout.ID_RES_NAV));
// assertTrue(shortcutList.contains(IPageLayout.ID_OUTLINE));
// assertTrue(shortcutList.contains(IPageLayout.ID_PROP_SHEET));
// assertTrue(shortcutList.contains(IPageLayout.ID_PROBLEM_VIEW));
// }
//
// /**
// * Tests the getPerspectiveShortcuts() method.
// *
// * @since 3.1
// */
// public void testGetPerspectiveShortcuts() {
// String[] shortcuts = fActivePage.getPerspectiveShortcuts();
// assertNotNull(shortcuts);
// assertEquals(0, shortcuts.length);
// // not much of a test
// }
//
// /**
// * Tests the getOpenPerspectives() method.
// *
// * @since 3.1
// */
// public void testGetOpenPerspectives() {
// IPerspectiveDescriptor[] openPersps = fActivePage.getOpenPerspectives();
// assertEquals(1, openPersps.length);
// assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId());
//
// IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry();
// IPerspectiveDescriptor resourcePersp = reg
// .findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID);
// fActivePage.setPerspective(resourcePersp);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(2, openPersps.length);
// assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId());
// assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[1].getId());
//
// IPerspectiveDescriptor emptyPersp = reg
// .findPerspectiveWithId(EmptyPerspective.PERSP_ID);
// fActivePage.setPerspective(emptyPersp);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(2, openPersps.length);
// assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId());
// assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[1].getId());
//
// fActivePage.closeAllPerspectives(false, false);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(0, openPersps.length);
//
// fActivePage.close();
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(0, openPersps.length);
// }
//
// /**
// * Tests the getSortedPerspectives() method.
// *
// * @since 3.1
// */
// public void testGetSortedPerspectives() {
// IPerspectiveDescriptor[] openPersps = fActivePage
// .getSortedPerspectives();
// assertEquals(1, openPersps.length);
// assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId());
//
// IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry();
// IPerspectiveDescriptor resourcePersp = reg
// .findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID);
// fActivePage.setPerspective(resourcePersp);
// openPersps = fActivePage.getSortedPerspectives();
// assertEquals(2, openPersps.length);
// assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId());
// assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[1].getId());
//
// IPerspectiveDescriptor emptyPersp = reg
// .findPerspectiveWithId(EmptyPerspective.PERSP_ID);
// fActivePage.setPerspective(emptyPersp);
// openPersps = fActivePage.getSortedPerspectives();
// assertEquals(2, openPersps.length);
// assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[0].getId());
// assertEquals(EmptyPerspective.PERSP_ID, openPersps[1].getId());
//
// fActivePage.closeAllPerspectives(false, false);
// openPersps = fActivePage.getSortedPerspectives();
// assertEquals(0, openPersps.length);
//
// fActivePage.close();
// openPersps = fActivePage.getSortedPerspectives();
// assertEquals(0, openPersps.length);
// }
//
// /**
// * Tests the closePerspective method.
// *
// * @since 3.1
// */
// public void testClosePerspective() {
// // TODO: Need to test variants with saveEditors==true
//
// IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry();
// IPerspectiveDescriptor emptyPersp = reg
// .findPerspectiveWithId(EmptyPerspective.PERSP_ID);
// IPerspectiveDescriptor resourcePersp = reg
// .findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID);
//
// fActivePage.setPerspective(resourcePersp);
// IPerspectiveDescriptor[] openPersps = fActivePage.getOpenPerspectives();
// assertEquals(2, openPersps.length);
//
// fActivePage.closePerspective(resourcePersp, false, false);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(1, openPersps.length);
// assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId());
//
// fActivePage.closePerspective(emptyPersp, false, false);
// assertEquals(fActivePage, fWin.getActivePage()); // page not closed
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(0, openPersps.length);
//
// fActivePage.setPerspective(emptyPersp);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(1, openPersps.length);
//
// fActivePage.closePerspective(emptyPersp, false, true);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(0, openPersps.length);
// assertNull(fWin.getActivePage()); // page closed
// }
//
// /**
// * Tests the closeAllPerspectives method.
// *
// * @since 3.1
// */
// public void testCloseAllPerspectives() {
// // TODO: Need to test variants with saveEditors==true
//
// IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry();
// IPerspectiveDescriptor emptyPersp = reg
// .findPerspectiveWithId(EmptyPerspective.PERSP_ID);
// IPerspectiveDescriptor resourcePersp = reg
// .findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID);
//
// fActivePage.setPerspective(resourcePersp);
// IPerspectiveDescriptor[] openPersps = fActivePage.getOpenPerspectives();
// assertEquals(2, openPersps.length);
//
// fActivePage.closeAllPerspectives(false, false);
// assertEquals(fActivePage, fWin.getActivePage()); // page not closed
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(0, openPersps.length);
//
// fActivePage.setPerspective(emptyPersp);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(1, openPersps.length);
//
// fActivePage.closeAllPerspectives(false, true);
// openPersps = fActivePage.getOpenPerspectives();
// assertEquals(0, openPersps.length);
// assertNull(fWin.getActivePage()); // page closed
// }
//
// /**
// * Regression test for Bug 76285 [Presentations] Folder tab does not
// * indicate current view. Tests that, when switching between perspectives,
// * the remembered old part correctly handles multi-view instances.
// */
// public void testBug76285() {
// IWorkbenchPage page = fActivePage;
// IPerspectiveDescriptor originalPersp = page.getPerspective();
// IPerspectiveDescriptor resourcePersp = PlatformUI.getWorkbench()
// .getPerspectiveRegistry().findPerspectiveWithId(
// IDE.RESOURCE_PERSPECTIVE_ID);
// // test requires switching between two different perspectives
// assertNotSame(originalPersp, resourcePersp);
//
// int n = 5;
// IViewPart[] views = new IViewPart[n];
// for (int i = 0; i < n; ++i) {
// try {
// views[i] = page.showView(MockViewPart.IDMULT, Integer
// .toString(i), IWorkbenchPage.VIEW_CREATE);
// } catch (PartInitException e) {
// fail(e.getMessage());
// }
// }
// assertEquals(5, page.getViews().length);
// for (int i = 0; i < n; ++i) {
// page.activate(views[i]);
// page.setPerspective(resourcePersp);
// assertFalse(page.getActivePart() instanceof MockViewPart);
// page.setPerspective(originalPersp);
// assertEquals(views[i], page.getActivePart());
// }
// }
//
// /**
// * Tests that IShowEditorInput.showEditorInput is called when a matching
// * editor is found during openEditor, and is not called when a new editor is
// * opened.
// *
// * @since 3.1
// */
// public void testShowEditorInput() throws Exception {
// IWorkbenchPage page = fActivePage;
// proj = FileUtil.createProject("testShowEditorInput");
// IFile file = FileUtil.createFile("a.mock1", proj);
// MockEditorPart part1 = (MockEditorPart) IDE.openEditor(page, file);
// assertFalse(part1.getCallHistory().contains("showEditorInput"));
//
// MockEditorPart part2 = (MockEditorPart) IDE.openEditor(page, file);
// assertTrue(part1 == part2);
// assertTrue(part2.getCallHistory().contains("showEditorInput"));
// }
//
// /**
// * Tests that the openEditor and findEditor variants that accepts match
// * flags work as expected.
// *
// * @since 3.2
// */
// public void testOpenAndFindEditorWithMatchFlags() throws Exception {
// IWorkbenchPage page = fActivePage;
// proj = FileUtil.createProject("testOpenEditorMatchFlags");
// IFile file1 = FileUtil.createFile("a.mock1", proj);
// IFile file2 = FileUtil.createFile("a.mock2", proj);
// FileEditorInput input1 = new FileEditorInput(file1);
// FileEditorInput input2 = new FileEditorInput(file2);
// String id1 = MockEditorPart.ID1;
// String id2 = MockEditorPart.ID2;
//
// // first editor (no match)
// MockEditorPart part1 = (MockEditorPart) page.openEditor(input1, id1,
// true, IWorkbenchPage.MATCH_INPUT);
// assertNotNull(part1);
//
// // same input, same id, matching input (should match part1)
// MockEditorPart part2 = (MockEditorPart) page.openEditor(input1, id1,
// true, IWorkbenchPage.MATCH_INPUT);
// assertTrue(part1 == part2);
//
// // same input, different id, matching input (should match part1)
// MockEditorPart part3 = (MockEditorPart) page.openEditor(input1, id2,
// true, IWorkbenchPage.MATCH_INPUT);
// assertTrue(part1 == part3);
//
// // same input, different id, matching input and id (no match)
// MockEditorPart part4 = (MockEditorPart) page.openEditor(input1, id2,
// true, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID);
// assertNotNull(part4);
// assertTrue(part4 != part1);
//
// // same input, same id, matching nothing (no match)
// MockEditorPart part5 = (MockEditorPart) page.openEditor(input1, id1,
// true, IWorkbenchPage.MATCH_NONE);
// assertNotNull(part5);
// assertTrue(part5 != part1);
// assertTrue(part5 != part4);
//
// // different input, same id, matching id (should match part5 instead of
// // part1, because it was active)
// MockEditorPart part6 = (MockEditorPart) page.openEditor(input2, id1,
// true, IWorkbenchPage.MATCH_ID);
// assertTrue(part6 == part5);
//
// // different input, different id, matching input and id (no match)
// MockEditorPart part7 = (MockEditorPart) page.openEditor(input2, id2,
// true, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID);
// assertNotNull(part7);
// assertTrue(part7 != part1);
// assertTrue(part7 != part4);
// assertTrue(part7 != part5);
//
// // At this point, there are 4 editors open:
// // part1 (input1, id1), part4 (input1, id2), part5 (input1, id1), and
// // part7 (input2, id2).
// // with part7 active.
//
// // find with MATCH_NONE is always empty
// IEditorReference[] refs = page.findEditors(input1, id1,
// IWorkbenchPage.MATCH_NONE);
// assertEquals(0, refs.length);
//
// // find input1 with MATCH_INPUT finds 3 editors: part1, part4 and part5
// // (in order)
// refs = page.findEditors(input1, null, IWorkbenchPage.MATCH_INPUT);
// assertEquals(3, refs.length);
// assertEquals(part1, refs[0].getPart(true));
// assertEquals(part4, refs[1].getPart(true));
// assertEquals(part5, refs[2].getPart(true));
//
// // find input2 with MATCH_INPUT finds 1 editor: part7
// refs = page.findEditors(input2, null, IWorkbenchPage.MATCH_INPUT);
// assertEquals(1, refs.length);
// assertEquals(part7, refs[0].getPart(true));
//
// // find id1 with MATCH_ID finds 2 editors: part1 and part5 (in order)
// refs = page.findEditors(null, id1, IWorkbenchPage.MATCH_ID);
// assertEquals(2, refs.length);
// assertEquals(part1, refs[0].getPart(true));
// assertEquals(part5, refs[1].getPart(true));
//
// // find id2 with MATCH_ID finds 2 editors: part4 and part7 (with part7
// // first because it was active)
// refs = page.findEditors(null, id2, IWorkbenchPage.MATCH_ID);
// assertEquals(2, refs.length);
// assertEquals(part7, refs[0].getPart(true));
// assertEquals(part4, refs[1].getPart(true));
//
// // find input1 and id1 with MATCH_INPUT and MATCH_ID finds 2 editors:
// // part1 and part5 (in order)
// refs = page.findEditors(input1, id1, IWorkbenchPage.MATCH_INPUT
// | IWorkbenchPage.MATCH_ID);
// assertEquals(2, refs.length);
// assertEquals(part1, refs[0].getPart(true));
// assertEquals(part5, refs[1].getPart(true));
//
// // find input1 and id2 with MATCH_INPUT and MATCH_ID finds 1 editors:
// // part4
// refs = page.findEditors(input1, id2, IWorkbenchPage.MATCH_INPUT
// | IWorkbenchPage.MATCH_ID);
// assertEquals(1, refs.length);
// assertEquals(part4, refs[0].getPart(true));
// }
//}